package com.tmz.cloudmall.cloudmallproduct.service.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.tmz.cloudmall.cloudmallcommon.common.exception.ServiceException;
import com.tmz.cloudmall.cloudmallproduct.domain.CategoryBrandRelation;
import com.tmz.cloudmall.cloudmallproduct.mapper.CategoryBrandRelationMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.tmz.cloudmall.cloudmallproduct.mapper.CategoryMapper;
import com.tmz.cloudmall.cloudmallproduct.domain.Category;
import com.tmz.cloudmall.cloudmallproduct.service.ICategoryService;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * 商品三级分类Service业务层处理
 * 
 * @author tmz
 * @date 2025-08-16
 */
@Service
@Slf4j
public class CategoryServiceImpl implements ICategoryService 
{
    @Resource
    private CategoryMapper categoryMapper;

    @Resource
    private CategoryBrandRelationMapper categoryBrandRelationMapper;

    /**
     * 查询商品三级分类
     * 
     * @param catId 商品三级分类主键
     * @return 商品三级分类
     */
    @Override
    public Category selectCategoryByCatId(Long catId)
    {
        return categoryMapper.selectCategoryByCatId(catId);
    }

    /**
     * 查询商品三级分类列表
     * 
     * @param category 商品三级分类
     * @return 商品三级分类
     */
    @Override
    public List<Category> selectCategoryList(Category category)
    {
        return categoryMapper.selectCategoryList(category);
    }

    /**
     * 新增商品三级分类
     * 
     * @param category 商品三级分类
     * @return 结果
     */
    @Override
    public int insertCategory(Category category)
    {
        return categoryMapper.insertCategory(category);
    }

    /**
     * 修改商品三级分类
     * 
     * @param category 商品三级分类
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateCategory(Category category)
    {
        // 1.初始变量
        int updateCat;
        int updateRel = 0;
        // 2.修改分类信息
        updateCat = categoryMapper.updateCategory(category);
        if(updateCat > 0){
            // 3.同步修改品牌分类关系
            Long catId = category.getCatId();
            String cateName = category.getName();
            // 4.执行品牌分类关系的更新
            LambdaUpdateWrapper<CategoryBrandRelation> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(CategoryBrandRelation::getCatelogId,catId)
                    .set(CategoryBrandRelation::getCatelogName,cateName);
            updateRel = categoryBrandRelationMapper.update(updateWrapper);
        }
        // 5. 返回结果
        if(updateCat == 1 && updateRel > 0){
            return updateRel;
        }else{
            log.error("商品分类修改异常：商品分类记录更新{}条记录，品牌分类关系更新成功{}条记录",updateCat,updateRel);
            throw  new ServiceException("商品分类修改异常");
        }
    }

    /**
     * 批量删除商品三级分类
     * 
     * @param catIds 需要删除的商品三级分类主键
     * @return 结果
     */
    @Override
    public int deleteCategoryByCatIds(Long[] catIds)
    {
        return categoryMapper.deleteCategoryByCatIds(catIds);
    }

    /**
     * 查询三级分类列表
     * @param category 查询条件
     * */
    @Override
    public List<Category> selectCategoryListWithTree(Category category) {
        // 1、查出所有分类数据
        LambdaQueryWrapper<Category> queryWrapper = new LambdaQueryWrapper<>();
        List<Category> categories = categoryMapper.selectList(queryWrapper);

        // 2、组装树结构：先过滤一级分类，再递归设置子分类并排序
        List<Category> level1Menus = new ArrayList<>();

        // 筛选一级分类（parentCid == 0）
        for (Category cate : categories) {
            if (cate.getParentCid() == 0) {
                level1Menus.add(cate);
            }
        }

        // 为一级分类设置子分类并排序
        for (Category level1 : level1Menus) {
            // 递归获取子分类
            level1.setChildren(getChildren(level1, categories));
        }

        return level1Menus;
    }


    /**
     * 逻辑删除商品三级分类
     * 1、更新商品分类的显示状态字段，实现商品分类的逻辑删除
     * 2、更新前校验信息
     * @param catIds 待删除商品分类集合
     * */
    @Override
    public int deleteCategoryByCatIdsWithLogic(Long[] catIds) {
        // 1. 校验参数
        if (catIds == null || catIds.length == 0) {
            // 可以根据实际需求抛出异常或返回错误码，这里简单返回0表示操作失败
            log.error("逻辑删除异常：未指定需要删除的商品分类");
            throw new ServiceException("逻辑删除异常：未指定需要删除的商品分类");
        }

        List<Long> catIdList = Arrays.asList(catIds);
        // 2. 校验改分类下是否还有品牌，存在则不予删除，否则可删
        LambdaQueryWrapper<CategoryBrandRelation> relMapper = new LambdaQueryWrapper<>();
        relMapper.eq(CategoryBrandRelation::getCatelogId,catIdList.get(0));
        List<CategoryBrandRelation> relations = categoryBrandRelationMapper.selectList(relMapper);
        if(CollectionUtils.isNotEmpty(relations)){
            log.error("商品分类逻辑删除异常：该分类下仍存在品牌，禁止删除，品牌如下{}",relations);
            throw new ServiceException("商品分类逻辑删除异常：该分类下仍存在品牌，禁止删除，品牌如下"+relations);
        }
        // 2. 执行逻辑删除（更新showStatus字段为0，表示不显示，即逻辑删除）
        LambdaUpdateWrapper<Category> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.in(Category::getCatId, catIdList)
                .set(Category::getShowStatus, 0L);

        return categoryMapper.update(null, updateWrapper);
    }

    /**
     * 递归查找所有菜单的子菜单
     * @param root 父级商品类别
     * @param all 所有分类数据
     */
    private List<Category> getChildren(Category root, List<Category> all){
        List<Category> children = new ArrayList<>();

        // 筛选当前父节点的子分类
        for (Category cate : all) {
            // 判断当前分类的父ID是否等于根节点的ID
            if (root.getCatId().equals(cate.getParentCid())) {
                children.add(cate);
            }
        }

        // 递归为子分类设置它们的子分类
        for (Category child : children) {
            child.setChildren(getChildren(child, all));
        }

        return children;
    }
}
